Computer Music Interactif…cial Edition 1999 Winter/cd 3.iso/mac/Mac/Shares/Midishare™1.68/Development Tools/Sources Examples/msDisplay/msDisplay.p

Text File | 1992-03-08 | 27.6 KB | 802 lines | [TEXT/MPS ]

{[j=14/60/0]}
{••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••}
{•                                  DISPLAY                                     •}
{•------------------------------------------------------------------------------•}
{•                                                                                 •}
{• Le programme DISPLAY présenté ici, fait partie d'une série d'exemples à         •}
{• caractère pédagogique (enfin j'espère !) sur la façon d'utiliser MIDISHARE.    •}
{•                                                                                 •}
{• DISPLAY affiche en permanence et sans aucun filtrage les événements Midi     •}
{• reçus. Les informations affichées sont la date : en heures, minutes, secondes•}
{• et millièmes, la provenance : port et canal Midi, le type d'événement : note    •}
{• keyOn, etc... et les données complémentaires : hauteur, vélocité, etc...        •}
{•------------------------------------------------------------------------------•}
{• Release 1.2 (Avril 90)                                                        •}
{•            - bugs sous Multifinder (DAs, activations, idle)                    •}
{•------------------------------------------------------------------------------•}
{•        © GRAME 1989/90, Yann Orlarey et Hervé Lequay                            •}
{••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••}


Program Display;

USES    Memtypes, Quickdraw, OSIntf, ToolIntf, PackIntf, Traps, MIDIShareUnit;

const    AppleID    = 128;    AppleMenu    = 1;
        FileID    = 129;    FileMenu    = 2;
        EditID    = 130;    EditMenu    = 3;
            UndoI    = 1;    CutI    = 3;    CopyI    = 4;    PasteI    = 5;    ClearI    = 6;

        WindowID     = 128;                         { ID fenêtre de l'application        }
        AboutID         = 129;                            { ID About                            }
        AlertID         = 500;

        maxDisp         = 21;                            { Nombre de lignes affichées        }

        resumeMask    = $01;                            { suspend/resume mask                }
var
    myWindow:                WindowPtr;            { ma fenêtre (qui est  un Dialog)    }
    dragRect:                 Rect;                { limite les mouvmnt de la fenêtre    }
    theScrollRect:            Rect;                { le rectangle d'affichage            }
    TheScrollRgn:            RgnHandle;            { la region pour scrollRect }
    myMenus:                 ARRAY [AppleMenu..EditMenu] OF MenuHandle;
                                                 { la table des menus                }
    gMac:                    SysEnvRec;            { machine…                            }
    eventPending:            boolean;            { vrai si événement en attente        }
    hasWNE:                    boolean;            { vrai si WaitNextEvent implémenté    }
    foreGround:                boolean;            { vrai si en foreGround                }

    doneFlag:                 BOOLEAN;            { signale la fin de l'application     }
    myEvent:                 EventRecord;        { événement Macintosh                }

    whichChar:                 char;                { caractère clavier    Macintosh        }

    myRefNum:                integer;            { ID unique de l'appl. donné par MS }

    tname:                    array[typeNote..typeDead]
                                of string[8];    { Noms des événements MidiShare        }
    pname:                    array[0..1]
                                of string[7];    { Noms des ports Midi                }

    myFinfo:                fontInfo;            { info relatives aux Fonts            }
    myGrafPort:                grafPort;            { GrafPort en dehors de l'écran        }
    myGrafPtr:                grafPtr;            { pointeur sur ce GrafPort            }



(********************************************************************************)
(*                                 UTILITAIRES                                        *)
(*------------------------------------------------------------------------------*)
(* Routines pour MultiFinder                                                      *)
(*                                                                                 *)
(********************************************************************************)

{$S Initialize}
Function TRAPAVAILABLE (tNumber: integer; tType: trapType): boolean;
(*    Vérification de l'implémentation d'une trappe                                *)
begin
    TrapAvailable:= NGetTrapAddress(tNumber,tType) <> GetTrapAddress(_Unimplemented)
end;

{$S Main}
Function ISAPPWINDOW (aWind: windowPtr): boolean;
(* vérifie si la fenêtre appartient à l'application                                *)
begin
    if aWind = nil then
        IsAppWindow:= false
    else
        IsAppWindow:= windowPeek(aWind)^.windowKind >= 0
end;

{$S Main}
Function ISDAWINDOW (aWind: windowPtr): boolean;
(* vérifie si la fenêtre appartient à un accessoire de bureau                    *)
begin
    if aWind = nil then
        IsDAWindow:= false
    else
        IsDAWindow:= windowPeek(aWind)^.windowKind < 0
end;

{$S Main}
Procedure CenterRectOnScreen (var aRect: Rect);
{ aRect rectangle global à centrer sur écran (dragRect)                    }
var    screenSize    : Point;
    rectSize    : Point;
begin
    with dragRect do
        SetPt(screenSize,right - left,bottom - top);
    with aRect do begin
        SetPt(rectSize,right - left,bottom - top);
        left:= dragRect.left + (screenSize.h - rectSize.h) div 2;
        top:= dragRect.top + (screenSize.v - rectSize.v) div 5;
        topLeft:= point(PinRect(dragRect,topLeft));
        right:= left + rectSize.h;
        bottom:= top + rectSize.v;
        end;
end;

{$S Main}
Function GetNewCenteredDialog (dialogID: integer): DialogPtr;
var    dlogTemplate    : DialogTHndl;
begin
    GetNewCenteredDialog := nil;
    dlogTemplate := DialogTHndl(GetResource('DLOG', dialogID));
    if dlogTemplate <> nil then begin
        CenterRectOnScreen(dlogTemplate^^.boundsRect);
        GetNewCenteredDialog:= GetNewDialog(dialogID, nil, pointer(-1));
        end
    else SysBeep(2)                                                { At least give some indication }
end;

{$S Main}
Procedure AlertUser (alertID: integer);
var    alrtTemplate    : AlertTHndl;
    temp            : integer;
begin
    alrtTemplate := AlertTHndl(GetResource('ALRT', alertID));
    if alrtTemplate <> nil then begin
        SetCursor(arrow);
        CenterRectOnScreen(alrtTemplate^^.boundsRect);
        temp:= Alert(alertID,nil)
        end
    else SysBeep(2)                                             { At least give some indication        }
end;


(********************************************************************************)
(*                                 SHOW ABOUT                                        *)
(*------------------------------------------------------------------------------*)
(* Affiche le About de l'application.                                             *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
Procedure SHOWABOUT;
var    myDialog    : dialogPtr;
    hit            : integer;
begin
    myDialog:= GetNewCenteredDialog(AboutID);
    if myDialog <> nil then begin
        ModalDialog(nil,hit);
        DisposDialog(myDialog);
        end
end;


(********************************************************************************)
(*                                 INIT EVENT NAMES                                *)
(*------------------------------------------------------------------------------*)
(* Initialise les tables des noms des événements et des ports Midi tels qu'ils    *)
(* doivent être affichés.                                                        *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Initialize}
procedure InitEventNames;
var    i:    integer;
begin
    pname[0]:='   M/';                            { nom du port Modem                    }
    pname[1]:='   P/';                            { nom du port Imprimante            }

    for i := typePrivate to typeDead-1             { pas de nom pour ces codes            }
        do tname[i] :=            ' Undef  ';
    tname[typeNote]         := ' Note   ';        { donne un nom à tous les types        }
    tname[typeKeyOn]         := ' KeyOn  ';        { d'événements MidiShare.            }
    tname[typeKeyOff]         := ' KeyOff ';
    tname[typeKeyPress]     := ' KPress ';
    tname[typeCtrlChange]     := ' CtrlCh ';
    tname[typeProgChange]     := ' ProgCh ';
    tname[typeChanPress]     := ' CPress ';
    tname[typePitchWheel]     := ' PWheel ';
    tname[typeSongPos]         := ' SgPos  ';
    tname[typeSongSel]         := ' SgSel  ';
    tname[typeClock]         := ' Clock  ';
    tname[typeStart]         := ' Start  ';
    tname[typeContinue]         := ' Cont   ';
    tname[typeStop]             := ' Stop   ';
    tname[typeTune]         := ' Tune   ';
    tname[typeActiveSens]     := ' ASens  ';
    tname[typeReset]         := ' Reset  ';
    tname[typeSysEx]         := ' SysEx  ';
    tname[typeStream]         := ' Stream ';
    tname[typeQuarterFrame]    := ' QFrame ';
    tname[typeDead]         := ' Dead   ';
end;


(********************************************************************************)
(*                                 TIME TO STRING                                    *)
(*------------------------------------------------------------------------------*)
(* Routine de conversion d'une date sur 32 bits en une chaine de caractères au    *)
(* format heures, minutes, secondes et milliemes (HH:MN:SS.MMM)                    *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        t    :    la date à convertir.                                            *)
(*        s    :    la chaine de caractères résultante                                *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
procedure timeToString(t: longint; var s: str255);
var    z:    integer;
begin
    z := ord('0');
    s := '00:00:00.000';
    s[12]:= char(z+(t mod 10)); t := t div 10;
    s[11]:= char(z+(t mod 10)); t := t div 10;
    s[10]:= char(z+(t mod 10)); t := t div 10;

    s[8]:= char(z+(t mod 10)); t := t div 10;
    s[7]:= char(z+(t mod 6)); t := t div 6;

    s[5]:= char(z+(t mod 10)); t := t div 10;
    s[4]:= char(z+(t mod 6)); t := t div 6;

    s[2]:= char(z+(t mod 10)); t := t div 10;
    s[1]:= char(z+(t mod 10)); t := t div 10;
end;


(********************************************************************************)
(*                                 EV TO STRING                                    *)
(*------------------------------------------------------------------------------*)
(* Routine de conversion d'un événement MidiShare en une chaine de caractères     *)
(* au format date, port, canal, type d'événement et données complémentaires.    *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        e    :    pointeur sur l'événement à convertir.                            *)
(*        s    :    la chaine de caractères résultante                                *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
procedure EvToString(e: midiEvPtr; var s: str255);
var i:    integer;
    t:    str255;
    n:    longint;
begin
    timeToString(e^.date,s);                                    { date                }
    if e^.port <= printerPort then                                 { port /            }
        s:= Concat(s,pname[e^.port])
    else begin
        numToString(e^.port,t);
        if e^.port < 10 then s:= Concat(s,'   ',t,'/')
        else if e^.port < 100 then s:= Concat(s,'  ',t,'/')
        end;
    numToString(e^.chan + 1,t);                                    { canal                }
    if e^.chan < 10 then
        s:= Concat(s,t,'  ',tname[e^.evType],'(')                { type                }
    else s:= Concat(s,t,' ',tname[e^.evType],'(');

    n := midiCountFields(e) - 1;
    for i:= 0 to n do begin
        numToString(midiGetField(e,i),t);                        { champs            }
        s:= Concat(s,t);
        if Ord(s[0]) >= 42 then begin
            if (Ord(s[0]) > 42) | (i < n) then begin
                s[0]:= Chr(42);
                s[42]:= '…'
                end;
            leave
            end
        else if i <> n then
            s:= Concat(s,' ')
        end;
    s:= Concat(s,')')
end;


(********************************************************************************)
(*                                 DRAW MY CONTENT                                    *)
(*------------------------------------------------------------------------------*)
(* Copie le contenu de la bitMap hors écran, dans la fenêtre.                    *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
procedure drawMyContent;
begin
    copyBits(myGrafPort.portBits, myWindow^.portBits,theScrollRect,theScrollRect,srcCopy,Nil)
end;


(********************************************************************************)
(*                                 DRAW MY WINDOW                                    *)
(*------------------------------------------------------------------------------*)
(* Affiche la fenêtre (qui est un Dialog) avec son contenu.                        *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
procedure drawMyWindow;
begin
    DrawDialog(myWindow);
    DrawMyContent
end;


(********************************************************************************)
(*                                 NEW LINE                                        *)
(*------------------------------------------------------------------------------*)
(* Positionne le point courant du GrafPort en début de ligne suivante et scroll    *)
(* la bitMap arrivé à la dernière ligne.                                        *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
Procedure NewLine;
var    d:    integer;
    p:    point;
begin
    getPen(p);                                    { prend la position actuelle.        }
    d := p.v+12+myFinfo.descent+myFinfo.leading;{ voit si une nouvelle ligne tient    }
    if d > theScrollRect.bottom then begin        { si ce n'est pas le cas :            }
        ScrollRect(theScrollRect,0,-12,theScrollRgn);    {  fait défiler la BitMap    }
        moveTo(15,p.v)                            {  va à la dernière ligne            }
    end else                                     { sinon:                            }
        moveTo(15,p.v+12);                        {  va à la ligne suivante            }
end;


(********************************************************************************)
(*                             TREAT MIDI EVENTS                                    *)
(*------------------------------------------------------------------------------*)
(* La procedure TreatMidiEvents et chargée de la réception des événements Midi. *)
(* Elle est appelée périodiquement, dans la boucle principale du programme.        *)
(*                                                                                 *)
(* TreatMidiEvents va consulter le fifo de réception de l'application et         *)
(* afficher les événements qui si trouvent.    Suivant la rapidité du flot Midi     *)
(* l'application peut prendre du retard et accumuler trop d'événements dans son    *)
(* fifo. Dans ce cas, les événements exédentaires sont tout simplement détruits.*)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
procedure treatMidiEvents;
var    n,i:    integer;
    s:        str255;
    e:        midiEvPtr;

    function     Min(n1,n2: longint): longint;
    begin
        if n1<n2 then min := n1 else min := n2
    end;

begin
    n := MidiCountEvs(myRefNum);                { Compte le nombre d'événements en attente    }
    while n > maxDisp do begin                    { Si trop d'événements ont été accumulés    }
        MidiFreeEv(midiGetEv(myRefNum));        {  on en détruit pour rattraper le retard.    }
        n := n-1;
    end;
    if n>0 then begin                            { S'il y a des événements à afficher :        }
        setPort(myGrafPtr);                        {  on se prépare à dessiner hors écran,        }
        for i := 1 to min(n,3) do begin            {  on ne traite pas plus de 3 Ev à la fois    }
            e := midiGetEv(myRefNum);            {  on récupère l'événement dans le fifo        }
            evToString(e,s);                    {  conversion de l'Ev en chaine de car.        }
            midiFreeEv(e);                        {  on pense bien à libérer l'événement        }
            newLine;                            {  ligne suivante, avec un eventuel scroll    }
            drawString(s);                        {  affiche hors écran.                        }
        end;
        setPort(myWindow);                        { Retour au dessin sur l'écran.                }
        drawMyContent;                            { Affichage véritable.                        }
    end
end;


(********************************************************************************)
(*                                 SET UP MIDI                                        *)
(*------------------------------------------------------------------------------*)
(* Cette procédure définit les différents paramètres necessaires au fonction-    *)
(* nement Midi de l'application. Tout d'abord, le MidiOpen de l'application        *)
(* qui lui permet de se signaler à MidiShare, et d'obtenir un numèro de réfé-    *)
(* rence unique pour la suite des opérations. La chaine de caractères passée en    *)
(* argument sert au catalogue des applications ouvertes que maintient MidiShare.*)
(* Ensuite l'établissement d'une connection qui va relier l'entrée de l'appli-    *)
(* cation aux ports Midi d'arrivée.    Enfin la création d'une table de corres-    *)
(* pondance entre les codes et noms des événements reçus.                        *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Initialize}
procedure SetUpMidi;
var    name:        str255;
    apRefNum:    integer;
    apParam:    Handle;
    aRefNum:    integer;

    Procedure FAILSETUP (strIndex: integer);
    var    msgStr:    str255;
    begin
        GetIndString (msgStr,AlertID,strIndex);        { message d'alerte suivant erreur    }
        ParamText(name,msgStr,'','');
        AlertUser(AlertID);
        ExitToShell                                    { et quitte                            }
    end;

begin
    GetAppParms(name,apRefNum,apParam);                { récupérer le nom d'application    }
    if not MidiShare then FailSetUp(1);                { MidiShare n'est pas installé        }

    myRefNum:= MidiOpen(name);                        { ouverture en Midi                    }
    if myRefNum = MidiErrSpace then FailSetUp(2);    { impossible, plus de place            }

    midiConnect(0,myRefNum,true);            { connection avec les ports Midi d'entrées    }
    InitEventNames;                            { création de la table des noms.            }
end;


(********************************************************************************)
(*                             SET UP WINDOWS                                        *)
(*------------------------------------------------------------------------------*)
(* Procédure chargé d'ouvrir la fenêtre et de réaliser les initialisations         *)
(* necessaires. Ici l'affichage est un peu spécial, il se fait tout d'abord sur    *)
(* une BitMap hors écran, qui est ensuite copiée sur l'écran.                    *)
(*                                                                                *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Initialize}
procedure SetUpWindows;
var    r    : rect;
begin
    setRect(theScrollRect,11, 24, 274, 278);    { définition des coord. du rect. d'affichage}
    theScrollRgn := newRgn;                        { alloue la region de scroll                }
    myGrafPtr := @myGrafPort;                    { définition d'un GrafPort hors de l'écran    }
    openPort(myGrafPtr);                        { ouverture du grafPort                        }
    with myGrafPtr^.portBits do begin            { définition de sa bitMap                    }
        baseAddr := newPtr(40*40*8);            {  taille de 320 x 320                        }
        rowBytes := 40;                            {  soit 40 octets par lignes                }
        bounds := theScrollRect                    {  avec les coordonnées définies plus haut    }
    end;
    setPort(myGrafPtr);                            { On en fait le port courant :                }
    textFont(Monaco);textSize(9);                {  choix de divers paramètres d'écriture    }
    textMode(srcCopy); PenNormal;                {  et de dessin.                            }
    eraseRect(theScrollRect);                    {  efface la totalité de la bitMap.            }
    moveTo(15,21);                                {  position au dessus de la 1er ligne        }

    with screenBits.bounds do                    { rect max de déplacmt de fenêtre            }
        SetRect(dragRect, 4, 24, right - 4, bottom - 4);
    myWindow := GetNewDialog(WindowID,nil,pointer(-1));
    SetPort(myWindow);
    textFont(Monaco);textSize(9);                {  choix de divers paramètres d'écriture    }
    textMode(srcCopy); PenNormal;                {  et de dessin.                            }
    GetFontInfo(myFinfo);                        {  pour connaitre la hauteur des lignes        }

    r:= myWindow^.portRect;
    with r do begin
        LocalToGlobal(topLeft);
        LocalToGlobal(botRight)
        end;
    if not RectInRgn(r,GetGrayRgn) then begin    { fenêtre hors écran : centrée                }
        CenterRectOnScreen(r);
        MoveWindow(myWindow,r.left,r.top,true)
        end;
    ShowWindow(myWindow)
end;


{$S Main}
Procedure SaveWindowPos;
type    rectPtr  =     ^rect;
        rectHdle =    ^rectPtr;
var    windHdle:    handle;
begin
    windHdle:= Get1Resource('DLOG',WindowID);
    rectHdle(windHdle)^^:= windowPeek(myWindow)^.contRgn^^.rgnBBox;
    ChangedResource(windHdle);
    if ResError = noErr then
        WriteResource(windHdle)
end;


(********************************************************************************)
(*                                 SET UP MENUS                                    *)
(*------------------------------------------------------------------------------*)
(* Définition de la barre des menus.                                             *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun paramètre.                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Initialize}
Procedure SetUpMenus;
var    i:    integer;
begin
    myMenus[AppleMenu] := GetMenu(AppleID);
    AddResMenu(myMenus[AppleMenu], 'DRVR');
    myMenus[FileMenu] := GetMenu(FileID);
    myMenus[EditMenu] := GetMenu(EditID);            { menu Edit                            }
    FOR i := AppleMenu TO EditMenu DO
        InsertMenu(myMenus[i], 0);
    DrawMenuBar
end;


(********************************************************************************)
(*                                 INITIALIZE                                        *)
(*------------------------------------------------------------------------------*)
(* Initialisations générales (hasWNE, foreGround, managers, fenêtre, Midi)        *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun                                                                    *)
(*                                                                                 *)
(********************************************************************************)

{$S Initialize}
Procedure INITIALIZE;
var    err:    OSErr;
begin
    err:= SysEnvirons(1,gMac);
    hasWNE:= (gMac.machineType >= 0) & TrapAvailable(_WaitNextEvent,ToolTrap);

    InitGraf(@thePort);                                { initialisations standard            }
    InitFonts;
    InitWindows;
    InitMenus;
    TEInit;
    InitDialogs(NIL);
    InitCursor;
    SetUpMenus;                                        { mise en place menus                }
    SetUpMidi;                                        { ouverture MidiShare                }
    SetUpWindows;                                    { initialisations fenêtre et listes    }
end;


(********************************************************************************)
(*                                 ADJUST MENUS                                    *)
(*------------------------------------------------------------------------------*)
(* Ajustement de la barre de menus suivant la fenêtre de premier plan, juste    *)
(* lors d'un click dans la barre des menus                                        *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        aucun                                                                    *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
Procedure ADJUSTMENUS;
begin
    if IsAppWindow(FrontWindow) then begin
        DisableItem(myMenus[EditMenu],UndoI);
        DisableItem(myMenus[EditMenu],CutI);
        DisableItem(myMenus[EditMenu],CopyI);
        DisableItem(myMenus[EditMenu],PasteI);
        DisableItem(myMenus[EditMenu],ClearI)
        end
    else
    if IsDAWindow(FrontWindow) then begin
        EnableItem(myMenus[EditMenu],UndoI);
        EnableItem(myMenus[EditMenu],CutI);
        EnableItem(myMenus[EditMenu],CopyI);
        EnableItem(myMenus[EditMenu],PasteI);
        EnableItem(myMenus[EditMenu],ClearI)
        end
end;


(********************************************************************************)
(*                                 DO COMMAND                                        *)
(*------------------------------------------------------------------------------*)
(* Execution des commandes du menu.                                                 *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        mResult     :    le menu et l'item sélectionnés                            *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
Procedure DOCOMMAND ( mResult: LONGINT);
var    theItem:    integer;
    name:        str255;
    sysEdit:    boolean;

begin
    theItem := LoWord(mResult);
    case HiWord(mResult) of
        AppleID:
            if theItem <> 1 then begin
                GetItem(myMenus[AppleMenu], theItem, name);
                theItem := OpenDeskAcc(name)  end
            else showAbout;
        FileID:
            doneFlag := TRUE;
        EditID:                                        { menu Edit: uniquement pour DAs    }
            sysEdit := SystemEdit(theItem-1);
    end;
    HiliteMenu(0)
end;


(********************************************************************************)
(*                                 DO MOUSE DOWN                                    *)
(*------------------------------------------------------------------------------*)
(* Gère les clicks souris                                                        *)
(*                                                                                 *)
(* Les paramètres de l'appel :                                                    *)
(* ---------------------------                                                    *)
(*                                                                                 *)
(*        anEvent: l'événement                                                    *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
Procedure DOMOUSEDOWN (anEvent: eventRecord);
var    whichWind:    windowPtr;
    part:        integer;
begin
    part:= FindWindow(anEvent.where, whichWind);
    case part of
        inMenuBar:        begin
                        AdjustMenus;
                        DoCommand(MenuSelect(anEvent.where))
                        end;
        inSysWindow:    SystemClick(anEvent,whichWind);
        inDrag:         DragWindow(whichWind,anEvent.where,dragRect);
        inGoAway:        if IsAppWindow(whichWind) then
                            doneFlag:= TrackGoAway(whichWind,anEvent.where);
        inContent:        if whichWind <> FrontWindow then
                            SelectWindow(whichWind);
        end
end;


(********************************************************************************)
(*                                 ADJUST CURSOR                                    *)
(*------------------------------------------------------------------------------*)
(* Ajuste le curseur suivant région et fenêtre                                    *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
Procedure ADJUSTCURSOR;
begin
    if foreGround and IsAppWindow(FrontWindow) then
        SetCursor(arrow)
end;


(********************************************************************************)
(*                                 CLOSE WINDOWS                                    *)
(*------------------------------------------------------------------------------*)
(* Pour terminer correctement l'application: fermeture de toutes les fenêtres    *)
(* (application et DA's)                                                        *)
(*                                                                                 *)
(********************************************************************************)

{$S Main}
Procedure CLOSEWIND (aWind: windowPtr);
(* ferme une fenêtre                                                            *)
begin
    if IsDAWindow(aWind) then
        CloseDeskAcc(windowPeek(aWind)^.windowKind)
    else if IsAppWindow(aWind) then
        DisposeWindow(aWind)
end;

Procedure CLOSEALLWINDS;
(* ferme toutes les fenêtres                                                    *)
var    window:    windowPtr;
begin
    repeat
        window:= FrontWindow;
        if window <> nil then
            CloseWind(window);
    until window = nil;
end;


Procedure _DataInit;        EXTERNAL;

(********************************************************************************)
(*                         Corps principal du programme                            *)
(*------------------------------------------------------------------------------*)
(* Ouverture des différents managers, Initialisations diverses et boucle prin-    *)
(* cipale typique d'une application Macintosh.                                     *)
(********************************************************************************)

{$S Main}
begin
    UnLoadSeg(@_DataInit);
    MaxApplZone;
    Initialize;
    UnLoadSeg(@Initialize);

    DoneFlag:=false;                                { flag de terminaison                }
    repeat                                            { boucle principale typique            }
        if hasWNE then
            eventPending:= WaitNextEvent(everyEvent, myEvent, 20, nil)
                                                    { no sleep, no mouseRgn                }
        else begin
            SystemTask;
             eventPending:= GetNextEvent(everyEvent, myEvent)
        end;
        AdjustCursor;                                { si ≠ curseurs ou mouseRgn, ici    }
        with myEvent do
            case what of
                nullEvent:
                    treatMidiEvents;
                osEvt:
                    case BSR(message,24) of
                        suspendResumeMessage:
                            foreGround:= BAnd(message,resumeMask) <> 0;
                        mouseMovedMessage:
                            treatMidiEvents;
                    end;
                  keyDown, autoKey:
                    IF IsAppWindow(FrontWindow) then begin
                          whichChar := CHR(BAnd(message, charCodeMask));
                         IF BAnd(modifiers, cmdKey) <> 0 then
                            DoCommand(MenuKey(whichChar))
                    end;
                mouseDown:
                    DoMouseDown(myEvent);
                  updateEvt:
                    if IsAppWindow(windowPtr(message)) then begin
                        BeginUpdate(windowPtr(message));
                        if not EmptyRgn(windowPtr(message)^.visRgn) then begin
                            SetPort(windowPtr(message));
                            drawMyWindow
                            end;
                        EndUpdate(windowPtr(message))
                    end
            end
    UNTIL doneFlag;
    disposeRgn(theScrollRgn);
    MidiClose(myRefNum);                    { signale à MidiShare la fin de l'application    }
    SaveWindowPos;
    CloseAllWinds;
    ExitToShell
end.